/**
 * 数据导入服务
 * 提供账号和标签数据的导入功能
 */

import { addAccount } from '../accountService.js';
import { addTag } from '../tagService.js';

/**
 * 导入我们自家的备份文件
 * @param {string} fileData 文件数据（JSON、TEXT或加密格式）
 * @param {string} password 解密密码（如果是加密文件）
 * @returns {Promise<Object>} 导入结果
 */
export async function importOwnBackup(fileData, password) {
	try {
		let data;
		
		// 判断文件类型
		if (fileData.startsWith('ACCOUNTBOX_JSON_')) {
			// JSON 格式
			const lines = fileData.split('\n');
			if (lines.length < 2) {
				throw new Error('JSON 文件格式错误');
			}
			data = JSON.parse(lines[1]);
		} else if (fileData.startsWith('ACCOUNTBOX_TEXT_')) {
			// TEXT 格式
			return parseTextFormat(fileData);
		} else if (fileData.startsWith('{')) {
			// 纯JSON格式（兼容旧格式）
			data = JSON.parse(fileData);
		} else {
			// 加密文件，需要解密
			const decryptedData = await decryptData(fileData, password);
			if (decryptedData.startsWith('ACCOUNTBOX_JSON_')) {
				const lines = decryptedData.split('\n');
				data = JSON.parse(lines[1]);
			} else {
				data = JSON.parse(decryptedData);
			}
		}
		
		// 导入标签
		let importedTags = 0;
		if (data.tagList && Array.isArray(data.tagList)) {
			for (const tag of data.tagList) {
				try {
					if (tag.tagName && tag.tagName.trim() !== '') {
						addTag(tag.tagName);
						importedTags++;
					}
				} catch (error) {
					// 标签已存在或其他错误，忽略
					console.error('导入标签失败:', error);
				}
			}
		}
		
		// 导入账号
		let importedAccounts = 0;
		let skippedAccounts = 0;
		
		if (data.accountList && Array.isArray(data.accountList)) {
			for (const account of data.accountList) {
				try {
					// 检查必填字段
					if (!account.name || account.name.trim() === '') {
						skippedAccounts++;
						continue;
					}
					
					// 转换账号字段
					const accountItemList = account.accountItemList || [];
					const accountData = {
						name: account.name,
						account: '',
						password: '',
						note: '',
						isFavorite: account.favorite || false,
						customFields: {}
					};
					
					// 解析 accountItemList
					accountItemList.forEach(item => {
						if (item.itemName === '账号') {
							accountData.account = item.itemValue || '';
						} else if (item.itemName === '密码') {
							accountData.password = item.itemValue || '';
						} else if (item.itemName === '备注') {
							accountData.note = item.itemValue || '';
						} else {
							// 自定义字段
							accountData.customFields[item.itemName] = item.itemValue || '';
						}
					});
					
					// 处理标签
					if (account.tagList && Array.isArray(account.tagList) && account.tagList.length > 0) {
						const tagNames = account.tagList.map(t => t.tagName).filter(t => t);
						accountData.tag = tagNames.join(',');
					}
					
					// 导入账号
					addAccount(accountData);
					importedAccounts++;
				} catch (error) {
					skippedAccounts++;
					console.error('导入账号失败:', error);
				}
			}
		}
		
		return {
			success: true,
			importedAccounts,
			skippedAccounts,
			importedTags,
			message: `成功导入 ${importedAccounts} 个账号，${importedTags} 个标签`
		};
	} catch (error) {
		throw new Error('导入备份文件失败: ' + error.message);
	}
}

/**
 * 导入其他第三方平台数据
 * @param {string} fileData 文件数据
 * @param {string} platform 平台名称
 * @returns {Promise<Object>} 导入结果
 */
export async function importThirdPartyData(fileData, platform) {
	try {
		let accounts = [];
		
		// 根据不同平台解析数据
		switch (platform) {
			case '1password':
				accounts = parse1Password(fileData);
				break;
			case 'lastpass':
				accounts = parseLastPass(fileData);
				break;
			case 'csv':
				accounts = parseCSV(fileData);
				break;
			default:
				throw new Error('不支持的平台格式');
		}
		
		// 导入账号
		let importedAccounts = 0;
		let skippedAccounts = 0;
		
		for (const account of accounts) {
			try {
				if (!account.name || account.name.trim() === '') {
					skippedAccounts++;
					continue;
				}
				
				addAccount({
					name: account.name,
					account: account.account || '',
					password: account.password || '',
					note: account.note || '',
					tag: account.tag || ''
				});
				importedAccounts++;
			} catch (error) {
				skippedAccounts++;
				console.error('导入账号失败:', error);
			}
		}
		
		return {
			success: true,
			importedAccounts,
			skippedAccounts,
			message: `成功导入 ${importedAccounts} 个账号`
		};
	} catch (error) {
		throw new Error('导入第三方数据失败: ' + error.message);
	}
}

/**
 * 解密数据（待实现）
 * @param {string} encryptedData 加密的数据
 * @param {string} password 密码
 * @returns {Promise<string>} 解密后的数据
 */
async function decryptData(encryptedData, password) {
	// TODO: 实现解密算法
	// 需要与加密算法对应
	return Promise.resolve(encryptedData); // 临时返回，待实现
}

/**
 * 解析 1Password 格式数据
 * @param {string} data 文件数据
 * @returns {Array} 账号列表
 */
function parse1Password(data) {
	// TODO: 实现 1Password 格式解析
	return [];
}

/**
 * 解析 LastPass 格式数据
 * @param {string} data 文件数据
 * @returns {Array} 账号列表
 */
function parseLastPass(data) {
	// TODO: 实现 LastPass 格式解析
	return [];
}

/**
 * 解析 TEXT 格式数据
 * @param {string} fileData TEXT 文件数据
 * @returns {Promise<Object>} 导入结果
 */
async function parseTextFormat(fileData) {
	try {
		const lines = fileData.split('\n');
		
		// 从第12行开始解析（前11行是模板说明）
		let importedAccounts = 0;
		let skippedAccounts = 0;
		const importedTags = new Set();
		
		let currentAccount = null;
		
		for (let i = 11; i < lines.length; i++) {
			const line = lines[i].trim();
			
			if (!line) {
				// 空行表示一个账号结束
				if (currentAccount) {
					if (currentAccount.name) {
						try {
							addAccount(currentAccount);
							importedAccounts++;
							
							// 收集标签
							if (currentAccount.tag) {
								const tags = currentAccount.tag.split('，').map(t => t.trim()).filter(t => t);
								tags.forEach(tag => importedTags.add(tag));
							}
						} catch (error) {
							skippedAccounts++;
						}
					} else {
						skippedAccounts++;
					}
					currentAccount = null;
				}
				continue;
			}
			
			// 解析字段（格式：字段名：值）
			const colonIndex = line.indexOf('：');
			if (colonIndex === -1) continue;
			
			const fieldName = line.substring(0, colonIndex).trim();
			const fieldValue = line.substring(colonIndex + 1).trim();
			
			if (!currentAccount) {
				currentAccount = {
					name: '',
					account: '',
					password: '',
					note: '',
					tag: '',
					customFields: {}
				};
			}
			
			if (fieldName === '名称') {
				currentAccount.name = fieldValue;
			} else if (fieldName === '账号') {
				currentAccount.account = fieldValue;
			} else if (fieldName === '密码') {
				currentAccount.password = fieldValue;
			} else if (fieldName === '备注') {
				currentAccount.note = fieldValue;
			} else if (fieldName === '标签') {
				currentAccount.tag = fieldValue.replace(/，/g, ','); // 中文逗号转为英文逗号
			} else {
				// 自定义字段
				currentAccount.customFields[fieldName] = fieldValue;
			}
		}
		
		// 处理最后一个账号
		if (currentAccount && currentAccount.name) {
			try {
				addAccount(currentAccount);
				importedAccounts++;
				
				if (currentAccount.tag) {
					const tags = currentAccount.tag.split('，').map(t => t.trim()).filter(t => t);
					tags.forEach(tag => importedTags.add(tag));
				}
			} catch (error) {
				skippedAccounts++;
			}
		}
		
		// 导入标签
		let importedTagsCount = 0;
		for (const tagName of importedTags) {
			try {
				addTag(tagName);
				importedTagsCount++;
			} catch (error) {
				// 标签已存在，忽略
			}
		}
		
		return {
			success: true,
			importedAccounts,
			skippedAccounts,
			importedTags: importedTagsCount,
			message: `成功导入 ${importedAccounts} 个账号，${importedTagsCount} 个标签`
		};
	} catch (error) {
		throw new Error('解析 TEXT 文件失败: ' + error.message);
	}
}

/**
 * 解析 CSV 格式数据
 * @param {string} data CSV 文件数据
 * @returns {Array} 账号列表
 */
function parseCSV(data) {
	try {
		const lines = data.split('\n');
		if (lines.length < 2) {
			throw new Error('CSV 文件格式错误');
		}
		
		// 解析表头
		const headers = lines[0].split(',').map(h => h.trim());
		const nameIndex = headers.findIndex(h => h.toLowerCase().includes('name') || h.toLowerCase().includes('标题'));
		const accountIndex = headers.findIndex(h => h.toLowerCase().includes('account') || h.toLowerCase().includes('账号') || h.toLowerCase().includes('username'));
		const passwordIndex = headers.findIndex(h => h.toLowerCase().includes('password') || h.toLowerCase().includes('密码'));
		const noteIndex = headers.findIndex(h => h.toLowerCase().includes('note') || h.toLowerCase().includes('备注'));
		
		if (nameIndex === -1) {
			throw new Error('CSV 文件中找不到名称字段');
		}
		
		// 解析数据行
		const accounts = [];
		for (let i = 1; i < lines.length; i++) {
			const values = lines[i].split(',').map(v => v.trim());
			if (values.length === 0 || !values[nameIndex]) continue;
			
			accounts.push({
				name: values[nameIndex],
				account: accountIndex !== -1 ? values[accountIndex] : '',
				password: passwordIndex !== -1 ? values[passwordIndex] : '',
				note: noteIndex !== -1 ? values[noteIndex] : ''
			});
		}
		
		return accounts;
	} catch (error) {
		throw new Error('解析 CSV 文件失败: ' + error.message);
	}
}

